STYLE: Use auto for variable creation

This check is responsible for using the auto type specifier for variable
declarations to improve code readability and maintainability.

The auto type specifier will only be introduced in situations where the
variable type matches the type of the initializer expression. In other words
auto should deduce the same type that was originally spelled in the source

cd /Users/johnsonhj/Dashboard/src/ITK-clangtidy/
run-clang-tidy.py -checks=-*,modernize-use-auto  -header-filter=.* -fix

use auto when declaring iterators
use auto when initializing with a cast to avoid duplicating the type name
use auto when initializing with a template cast to avoid duplicating the type name
use auto when initializing with new to avoid duplicating the type name

SRCDIR=/Users/johnsonhj/Dashboard/src/ITK #My local SRC
BLDDIR=/Users/johnsonhj/Dashboard/src/ITK-clangtidy/ #My local BLD

PERF: Replace explicit return calls of constructor

Replaces explicit calls to the constructor in a return with a braced
initializer list. This way the return type is not needlessly duplicated in the
function definition and the return statement.

SRCDIR=/Users/johnsonhj/Dashboard/src/ITK #My local SRC
BLDDIR=/Users/johnsonhj/Dashboard/src/ITK-clangtidy/ #My local BLD

cd /Users/johnsonhj/Dashboard/src/ITK-clangtidy/
run-clang-tidy.py -checks=-*,modernize-return-braced-init-list  -header-filter=.* -fix

PERF: Allow compiler to choose best way to construct a copy

With move semantics added to the language and the standard library updated with
move constructors added for many types it is now interesting to take an
argument directly by value, instead of by const-reference, and then copy. This
check allows the compiler to take care of choosing the best way to construct
the copy.

The transformation is usually beneficial when the calling code passes an rvalue
and assumes the move construction is a cheap operation. This short example
illustrates how the construction of the value happens:

class Foo {
 public:
-  Foo(const std::string &Copied, const std::string &ReadOnly)
-    : Copied(Copied), ReadOnly(ReadOnly) {}
+  Foo(std::string Moved, const std::string &ReadOnly)
+    : Copied(std::move(Moved)), ReadOnly(ReadOnly) {}
 private:
   private:
   std::string Copied;
   const std::string &ReadOnly;
};

SRCDIR=/Users/johnsonhj/Dashboard/src/ITK #My local SRC
BLDDIR=/Users/johnsonhj/Dashboard/src/ITK-clangtidy/ #My local BLD

cd /Users/johnsonhj/Dashboard/src/ITK-clangtidy/
run-clang-tidy.py -checks=-*,modernize-pass-by-value  -header-filter=.* -fix

STYLE: Use range-based loops from C++11

Used as a more readable equivalent to the traditional for loop operating
over a range of values, such as all elements in a container, in the
forward direction.

====
Range based loopes are more explicit for only computing the
end location once for containers.

for ( ImageIORegion::IndexType::const_iterator i = this->GetIndex().begin();
  i != this->GetIndex().end(); //<- NOTE: Compute end every loop iteration
  ++i )

for (long i : this->GetIndex()) //<- NOTE: Implicitly only compute end once

====
Explicitly reduce the amount of index computations: (The compiler
probably does this too)

for(int i = 0; i < 11; i++)
  {
  pos[0] = testPoints[i][0];
  pos[1] = testPoints[i][1];
                    ^^^^

for(auto & testPoint : testPoints)
  {
  pos[0] = testPoint[0];
  pos[1] = testPoint[1];

====

SRCDIR=/Users/johnsonhj/Dashboard/src/ITK #My local SRC
BLDDIR=/Users/johnsonhj/Dashboard/src/ITK-clangtidy/ #My local BLD

cd /Users/johnsonhj/Dashboard/src/ITK-clangtidy/
run-clang-tidy.py -checks=-*,modernize-loop-convert  -header-filter=.* -fix

ENH: Providing ITKv5 updates for C++11

== http://en.cppreference.com/w/cpp/language/type_alias ==

Type alias is a name that refers to a previously defined type (similar
to typedef).

A type alias declaration introduces a name which can be used as a
synonym for the type denoted by type-id. It does not introduce a new
type and it cannot change the meaning of an existing type name. There is
no difference between a type alias declaration and typedef declaration.
This declaration may appear in block scope, class scope, or namespace
scope.

== https://www.quora.com/Is-using-typedef-in-C++-considered-a-bad-practice ==

While typedef is still available for backward compatibility, the new
Type Alias syntax 'using Alias = ExistingLongName;' is more consistent
with the flow of C++ than the old typedef syntax 'typedef
ExistingLongName Alias;', and it also works for templates (Type alias,
alias template (since C++11)), so leftover 'typedef' aliases will differ
in style from any alias templates.

ENH: Providing ITKv5 updates for C++11

The mission of NumFOCUS is to promote open
practices in research, data, and scientific
computing.

https://numfocus.org

Use correct MultipleImageIterator-Test_LIBRARIES variable instead of
MultipleImageIterator_LIBRARIES for test driver creation.

…update-cid-tags

ENH: Convert ExternalData .md5 tags to .cid (IPFS content IDs)

- Add README pointing at archived upstream.
- Replace upstream COMPILE_DEPENDS with DEPENDS ITKCommon (header-only template).
- Inline DESCRIPTION instead of multi-line set(DOCUMENTATION).
- Add \ingroup ImageIterators topical tag.

- operator[] takes unsigned int (matches Size() return type and
  m_Iterators::operator[] signature; prevents silent negative-index UB).
- Remove 'using namespace std;' at global scope and explicitly qualify
  std:: usages in the test driver, per ITK code-style.